﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.Management;
using System.IO;
using Oliver.UI.LoadingCircle;
namespace Configure
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private Thread mthread;
        private bool run=true;
        private static TextBox[] lbs = new TextBox[20];
        private static uint[] crc32_stm32 = new uint[256]{
          0x00000000,0x04C11DB7,0x09823B6E,0x0D4326D9,0x130476DC,0x17C56B6B,0x1A864DB2,0x1E475005,
          0x2608EDB8,0x22C9F00F,0x2F8AD6D6,0x2B4BCB61,0x350C9B64,0x31CD86D3,0x3C8EA00A,0x384FBDBD,
          0x4C11DB70,0x48D0C6C7,0x4593E01E,0x4152FDA9,0x5F15ADAC,0x5BD4B01B,0x569796C2,0x52568B75,
          0x6A1936C8,0x6ED82B7F,0x639B0DA6,0x675A1011,0x791D4014,0x7DDC5DA3,0x709F7B7A,0x745E66CD,
          0x9823B6E0,0x9CE2AB57,0x91A18D8E,0x95609039,0x8B27C03C,0x8FE6DD8B,0x82A5FB52,0x8664E6E5,
          0xBE2B5B58,0xBAEA46EF,0xB7A96036,0xB3687D81,0xAD2F2D84,0xA9EE3033,0xA4AD16EA,0xA06C0B5D,
          0xD4326D90,0xD0F37027,0xDDB056FE,0xD9714B49,0xC7361B4C,0xC3F706FB,0xCEB42022,0xCA753D95,
          0xF23A8028,0xF6FB9D9F,0xFBB8BB46,0xFF79A6F1,0xE13EF6F4,0xE5FFEB43,0xE8BCCD9A,0xEC7DD02D,
          0x34867077,0x30476DC0,0x3D044B19,0x39C556AE,0x278206AB,0x23431B1C,0x2E003DC5,0x2AC12072,
          0x128E9DCF,0x164F8078,0x1B0CA6A1,0x1FCDBB16,0x018AEB13,0x054BF6A4,0x0808D07D,0x0CC9CDCA,
          0x7897AB07,0x7C56B6B0,0x71159069,0x75D48DDE,0x6B93DDDB,0x6F52C06C,0x6211E6B5,0x66D0FB02,
          0x5E9F46BF,0x5A5E5B08,0x571D7DD1,0x53DC6066,0x4D9B3063,0x495A2DD4,0x44190B0D,0x40D816BA,
          0xACA5C697,0xA864DB20,0xA527FDF9,0xA1E6E04E,0xBFA1B04B,0xBB60ADFC,0xB6238B25,0xB2E29692,
          0x8AAD2B2F,0x8E6C3698,0x832F1041,0x87EE0DF6,0x99A95DF3,0x9D684044,0x902B669D,0x94EA7B2A,
          0xE0B41DE7,0xE4750050,0xE9362689,0xEDF73B3E,0xF3B06B3B,0xF771768C,0xFA325055,0xFEF34DE2,
          0xC6BCF05F,0xC27DEDE8,0xCF3ECB31,0xCBFFD686,0xD5B88683,0xD1799B34,0xDC3ABDED,0xD8FBA05A,
          0x690CE0EE,0x6DCDFD59,0x608EDB80,0x644FC637,0x7A089632,0x7EC98B85,0x738AAD5C,0x774BB0EB,
          0x4F040D56,0x4BC510E1,0x46863638,0x42472B8F,0x5C007B8A,0x58C1663D,0x558240E4,0x51435D53,
          0x251D3B9E,0x21DC2629,0x2C9F00F0,0x285E1D47,0x36194D42,0x32D850F5,0x3F9B762C,0x3B5A6B9B,
          0x0315D626,0x07D4CB91,0x0A97ED48,0x0E56F0FF,0x1011A0FA,0x14D0BD4D,0x19939B94,0x1D528623,
          0xF12F560E,0xF5EE4BB9,0xF8AD6D60,0xFC6C70D7,0xE22B20D2,0xE6EA3D65,0xEBA91BBC,0xEF68060B,
          0xD727BBB6,0xD3E6A601,0xDEA580D8,0xDA649D6F,0xC423CD6A,0xC0E2D0DD,0xCDA1F604,0xC960EBB3,
          0xBD3E8D7E,0xB9FF90C9,0xB4BCB610,0xB07DABA7,0xAE3AFBA2,0xAAFBE615,0xA7B8C0CC,0xA379DD7B,
          0x9B3660C6,0x9FF77D71,0x92B45BA8,0x9675461F,0x8832161A,0x8CF30BAD,0x81B02D74,0x857130C3,
          0x5D8A9099,0x594B8D2E,0x5408ABF7,0x50C9B640,0x4E8EE645,0x4A4FFBF2,0x470CDD2B,0x43CDC09C,
          0x7B827D21,0x7F436096,0x7200464F,0x76C15BF8,0x68860BFD,0x6C47164A,0x61043093,0x65C52D24,
          0x119B4BE9,0x155A565E,0x18197087,0x1CD86D30,0x029F3D35,0x065E2082,0x0B1D065B,0x0FDC1BEC,
          0x3793A651,0x3352BBE6,0x3E119D3F,0x3AD08088,0x2497D08D,0x2056CD3A,0x2D15EBE3,0x29D4F654,
          0xC5A92679,0xC1683BCE,0xCC2B1D17,0xC8EA00A0,0xD6AD50A5,0xD26C4D12,0xDF2F6BCB,0xDBEE767C,
          0xE3A1CBC1,0xE760D676,0xEA23F0AF,0xEEE2ED18,0xF0A5BD1D,0xF464A0AA,0xF9278673,0xFDE69BC4,
          0x89B8FD09,0x8D79E0BE,0x803AC667,0x84FBDBD0,0x9ABC8BD5,0x9E7D9662,0x933EB0BB,0x97FFAD0C,
          0xAFB010B1,0xAB710D06,0xA6322BDF,0xA2F33668,0xBCB4666D,0xB8757BDA,0xB5365D03,0xB1F740B4
        };
        public static uint mECC(byte[] data, uint datalength)
        {
            uint ret = 0x7F;
            uint i = 0;
            for (i = 0; i < datalength; i++)
            {
                ret = ret ^ data[i];
            }
            return ret;
        }
        /// <summary>
        /// uint t = mCRC.get_crc32(0xffffffff, bfCRC,fislength);
        /// </summary>
        /// <param name="crc">校验初值</param>
        /// <param name="crcBuff">校验数据</param>
        /// <param name="crcLen">校验长度</param>
        /// <returns>四位结果</returns>
        public static uint get_crc32(uint crc, byte[] crcBuff, ulong crcLen)
        {
            ulong i;


            for (i = 0; i < crcLen; i++)
            {
                crc = (crc << 8) ^ crc32_stm32[(crc >> 24) ^ crcBuff[i]];
            }
            return crc;
        }
        private void Btn_Found_Device_Click(object sender, EventArgs e)
        { /// [00]05.26,000.0,000.0,000.0,00.00,00.00,00.00,00.00,00.00,00.00,051,+023,+023,C,O,O,O,O,O,00000,00000,00000,00000,O,O,O,O,O,O,O,O,V,0000.00000,N,0000.00000,E,000000.00,
            System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1));
            startTime = startTime.AddSeconds(85144);
            loadingCircle1.Active = true;
            lb_firmwareversion.Text = String.Format("{0:D2}{1:D2}",1,2);
            mthread = new Thread(new ThreadStart(startSearch));
            mthread.Start();
            mthread1 = new Thread(new ThreadStart(config_Receive));
            timer1.Enabled = true;
        }
        private Thread mthread1;
        private UdpClient udpConfig;
        private void startSearch()
        {
            run = true;
            byte[] m = Encoding.Unicode.GetBytes("hello yahmt");
            UdpClient client = new UdpClient(new IPEndPoint(IPAddress.Any, 7788));
            udpConfig = new UdpClient();
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text.Trim()), configPort);//update 7789 szbh 17788
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
            if (!mthread1.IsAlive)
            {
                mthread1.Start();
            }
            Thread.Sleep(1000);
            while (run)
            {
                if (run) { 
                    if(udpConfig!=null)
                    {
                        udpConfig.Send(m, m.Length, endpoint);
                        receiveConfigEndpoint = endpoint;
                        Thread.Sleep(1000);
                    }else
                    {
                        MessageBox.Show("client is none");
                    } 
                }
            }
            this.Invoke(new Func<string>(delegate() { loadingCircle1.Active = false; return "abnormal"; }));
            client.Close();
        }
        private void trackBar2_ValueChanged(object sender, EventArgs e)
        {
            lb_R_Value.Text =trackBar2.Value.ToString();
        }

        private void trackBar3_ValueChanged(object sender, EventArgs e)
        {
            lb_G_Value.Text = trackBar3.Value.ToString();
        }

        private void trackBar4_ValueChanged(object sender, EventArgs e)
        {
            lb_B_Value.Text = trackBar4.Value.ToString();
        }

        private void trackBar1_ValueChanged(object sender, EventArgs e)
        {
            ischanged = true;
            lb_bt_value.Text = trackBar1.Value.ToString();
        }

        private void button15_Click(object sender, EventArgs e)
        {
            run = true;
            UdpClient client = new UdpClient(new IPEndPoint(IPAddress.Any, configPort));
            endpoint =null;
            while (run)
            {
                byte[] buf = client.Receive(ref endpoint);
                if (buf.Length > 0)
                {
                    string msg = Encoding.Unicode.GetString(buf, 0, buf.Length);
                    lb_deviceName.Text = endpoint.Address.ToString() + endpoint.Port.ToString();
                    client.Send(new byte[] { 0xaa, 0xff }, 2,endpoint);
                    run = false;
                }
            }
            client.Close();
        }

        private void button16_Click(object sender, EventArgs e)
        {
            Button btn = (Button)sender;
           // btn.Visible = false;
            int index =Int32.Parse(btn.Tag.ToString());
            byte[] m = pack_port(3, index, Encoding.Unicode.GetBytes(lbs[index].Text).Length, Encoding.Unicode.GetBytes(lbs[index].Text));
            // UdpClient udpclient1 = new UdpClient();
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }
        private byte[] pack_port(int commd,int nb, int length, byte[] data)
        {
            byte[] tp = new byte[length+1];
            Array.Copy(data,0,tp,1,length);
            tp[0] = (byte)nb;
            return pack_data(commd, length + 1, tp);
        }
        private byte[] pack_data(int commd,int length,byte[] data)
        {
            byte[] mdata = new byte[length + 4];
            mdata[0] = 0xaa;
            mdata[1] = (byte)commd;
            mdata[2] = (byte)length;
            Array.Copy(data, 0, mdata, 3, length);
            mdata[length + 3] = 0x03;
            return mdata;
        }
        private void button9_Click(object sender, EventArgs e)
        {
            byte[] m =pack_data(1, Encoding.Unicode.GetBytes(tb_id.Text).Length,Encoding.Unicode.GetBytes(tb_id.Text));
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
        }
        private void button32_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(2, Encoding.Unicode.GetBytes(tb_name.Text).Length, Encoding.Unicode.GetBytes(tb_name.Text));
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
        }

        private void button33_Click(object sender, EventArgs e)
        {
            if (cbx_isfull.Checked)
            {
                byte[] m = pack_data(4, 1, new byte[] { 0x01 });
                // UdpClient udpclient1 = new UdpClient();
                endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
                if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            }
            else {
                byte[] m = pack_data(4, 1, new byte[] { 0x00 });
                // UdpClient udpclient1 = new UdpClient();
                endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
                if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                lbs[1] = tb_p1;
                lbs[2] = tb_p2;
                lbs[3] = tb_p3;
                lbs[4] = tb_p4;
                lbs[5] = tb_p5;
                lbs[6] = tb_p6;
                lbs[7] = tb_p7;
                lbs[8] = tb_p8;
                lbs[9] = tb_p9;
                lbs[10] = tb_p10;
                lbs[11] = tb_p11;
                lbs[12] = tb_p12;
                lbs[13] = tb_p13;
                lbs[14] = tb_p14;
                lbs[15] = tb_p15;
                lbs[16] = tb_p16;
                loadingCircle1.OuterCircleRadius = 60;
                loadingCircle1.InnerCircleRadius = 20;
                loadingCircle1.NumberSpoke = 50;
                loadingCircle1.Color = Color.WhiteSmoke;
            }
            catch (IOException)
            { }
        }

        private void button18_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(8,1,new byte[]{0x01});
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
        }

        private void button17_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(7, 1, new byte[] { 0x01 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
        }

        private void button15_Click_1(object sender, EventArgs e)
        {
            byte[] m = pack_data(5, Encoding.Unicode.GetBytes(tb_centerip.Text).Length, Encoding.Unicode.GetBytes(tb_centerip.Text));
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }
        private Int32 configPort = 17788; 
        private void button16_Click_1(object sender, EventArgs e)
        {
            byte[] m = pack_data(6, Encoding.Unicode.GetBytes(tb_centerport.Text).Length, Encoding.Unicode.GetBytes(tb_centerport.Text));
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }

        private void tb_centerport_TextChanged(object sender, EventArgs e)
        {

        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            run = false;
            timer1.Enabled = false;
            configReceiveData_switch = false;
            udpConfig.Close();
            lb_deviceName.Text = "Search Fail";
        }

        private void button6_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(9,1,new byte[]{0x01});
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }
        private UdpClient udpclient1 = new UdpClient();
        private IPEndPoint endpoint = null;
       
        private string path;
        private void btn_open_firme_Click(object sender, EventArgs e)
        {
            OpenFileDialog Op = new OpenFileDialog();
            if (Op.ShowDialog() == DialogResult.OK)
            {
                lb_fireware_path.Text = Op.FileName;
                path = Op.FileName;
                sendFileName = Op.SafeFileName;
                FileInfo info = new FileInfo(path);
               lb_max.Text="/"+(info.Length / 1024).ToString();
               lb_index.Text = "";
            }

        }
        Thread td;
        private void btn_update_Click(object sender, EventArgs e)
        {
            isSave = false;
            rb_isTcp.Enabled = false;
            if (!lb_fireware_path.Text.Equals(""))
            {
                td = new Thread(new ThreadStart(uploadfiles));
                td.Start();
            }
        }
        private EventWaitHandle _waitHandle = new AutoResetEvent(false);
        private EventWaitHandle _waitCheck = new AutoResetEvent(false);
        private List<string> files = new List<string>();
        private string file, sendFileName;
       // private int  partNub = 0,part = 0;
        private byte[] packetData(byte function,byte[] data,int length)
        {
            byte[] temp = new byte[length+5];
            temp[0] = 0xaa;
            temp[1] = function;
            temp[2] = (byte)(length/256);
            temp[3] = (byte)(length%256);
            Array.Copy(data, 0, temp, 4, length);
            temp[length + 4] = (byte)YHT.IOData.Check.mCkeck.mECC(data, (uint)length);
            return temp;
        }
        private IPEndPoint receiveConfigEndpoint;
        private IPEndPoint receiveEndpoint;
        private bool isReceive = false;
        private uint mcrc32 = 0;
        private void data_Receive()
        {
            byte[] receiveData = new byte[10];
            if (!isUsedTcp)
            {
                while (isReceive)
                {
                    try
                    {
                        receiveData = udpclient1.Receive(ref receiveEndpoint);
                    }
                    catch (SocketException)
                    {
                        continue;
                    }
                    catch (InvalidOperationException)
                    {
                        continue;
                    }
                    if (receiveData[0] == 0xaa && receiveData[1] == 0x00)
                    {
                        _waitHandle.Set();
                        Setbp_Box("", it, false);
                    }
                    else if (receiveData[0] == 0xab)
                    {
                        mcrc32 = (uint)(receiveData[1] * 16777216) + (uint)(receiveData[2] * 65536) + (uint)(receiveData[3] * 256) + receiveData[4];
                        if (mcrc32 == fileCRC32)
                        {
                            _waitHandle.Set();
                            Setbp_Box("", k, false);
                        }
                        else
                        {
                            Setbp_Box("", -1, false);
                        }
                    }
                    else
                    {
                    }
                }
            }
            else { //使用tcp
                while (isReceive)
                {
                    try
                    {
                        msocket.Receive(receiveData, receiveData.Length,SocketFlags.None);//.Receive(ref receiveEndpoint);
                    }
                    catch (SocketException)
                    {
                        continue;
                    }
                    if (receiveData[0] == 0xaa && receiveData[1] == 0x00)
                    {
                        _waitHandle.Set();
                        Setbp_Box("", it, false);
                    }
                    else if (receiveData[0] == 0xaa && receiveData[1] == 0x01)
                    {
                        if (isSave)
                        {
                            this.Invoke(new Func<string>(delegate() { lb_file_info.Text = "save and reboot..."; return "save and reboot..."; }));
                        }
                        else {
                            this.Invoke(new Func<string>(delegate() { lb_file_info.Text = "update file error"; return "update file error"; }));
                          //  isSave = false;
                        }
                        td.Abort();
                    }
                    else if (receiveData[0] == 0xab)
                    {
                        mcrc32 = (uint)(receiveData[1] * 16777216) + (uint)(receiveData[2] * 65536) + (uint)(receiveData[3] * 256) + receiveData[4];
                        if (mcrc32 == fileCRC32)
                        {
                            _waitHandle.Set();
                            Setbp_Box("", k, false);
                        }
                        else
                        {
                            Setbp_Box("", -1, false);
                        }
                    }
                    else
                    {
                    }
                }
            }
        }
        private bool configReceiveData_switch = true;
        private void config_Receive()
        {
            byte[] configReceiveData = new byte[10];
            while (configReceiveData_switch)
            {
                try
                {
                    configReceiveData = udpConfig.Receive(ref receiveConfigEndpoint);
                }
                catch (SocketException)
                {
                    continue;
                }
                if (configReceiveData[0] == 0xaa && configReceiveData[1] == 0x00)
                {
                    MessageBox.Show("Setting OK");
                }
                else
                {

                    string msg = Encoding.Unicode.GetString(configReceiveData, 0, configReceiveData.Length);
                    this.Invoke(new Func<string>(delegate() { lb_deviceName.Text = receiveConfigEndpoint.Address.ToString() + ":" + receiveConfigEndpoint.Port.ToString() + "  device  " + msg; timer1.Enabled = false; return "abnormal"; }));
                   run = false;
                }
            }
        }
        private  int it = 0,k=0;
        private uint fileCRC32 = 0;
        private void uploadfiles()
        {
            isReceive = true;
            if(!isUsedTcp){
                Thread rd = new Thread(new ThreadStart(data_Receive));
                rd.Start();
            }
            files.Clear();
            files.Add(path);
            int packesize = (int)nup_packesize.Value;
            for (int i = 0; i < files.Count; i++)
            {
                file = files[i].ToString();
             //   sendImageName = //names[i].ToString();
                try
                {
                    FileStream fsp = new FileStream(file, FileMode.Open, FileAccess.Read);
                    fsp.Lock(0, fsp.Length);
                    byte[] bfCRC = new byte[fsp.Length];
                    fsp.Read(bfCRC, 0, bfCRC.Length);
                    int fislength = bfCRC.Length;
                    fsp.Close();
                    fileCRC32 = YHT.IOData.Check.mCkeck.get_crc32(0xffffffff, bfCRC, (ulong)fislength);
                    byte[] nt1 = System.Text.Encoding.BigEndianUnicode.GetBytes(@"\Mounted Volume\YHT\Update\Temp\");
                    byte[] data1 = packetData(0xfc, nt1, nt1.Length);
                    try
                    {
                        if (!isUsedTcp)
                        {
                            endpoint = new IPEndPoint(IPAddress.Parse(tb_updateIP.Text.Trim()), 17789);
                            receiveEndpoint = endpoint;
                            udpclient1 = new UdpClient();
                            udpclient1.Send(data1, data1.Length, endpoint);
                        }
                        else {
                            msocket.Send(data1, data1.Length,SocketFlags.None);
                        }
                    }
                    catch (ObjectDisposedException) {
                        break;
                    }
                    _waitHandle.WaitOne(50000);
                    byte[] nt = System.Text.Encoding.BigEndianUnicode.GetBytes(sendFileName + @lb_remoteFile.Text);
                    byte[] data = packetData(0xfe, nt, nt.Length);
                    if (!isUsedTcp)
                    {
                        udpclient1.Send(data, data.Length, endpoint);
                    }
                    else {
                        msocket.Send(data, data.Length, SocketFlags.None);
                    }
                    _waitHandle.WaitOne(50000);
                    k = 0;
                    k = bfCRC.Length / packesize;
                    if (bfCRC.Length % packesize > 0)
                    {
                        k++;
                    }
                    Setbp_Box(sendFileName, k, true);
                    this.Invoke(new Func<string>(delegate() { lb_PackageSize.Text=""+k; return k.ToString(); }));
                    this.Invoke(new Func<string>(delegate() { lb_max.Text = "/" + k; return k.ToString(); }));
                    //partNub = 0;
                  //  part = 0;
                    for (it = 0; it < (int)(fislength / packesize); it++)
                    {
                        /*********禁用了线程傻傻等待，启用了更智能的事件驱动模型-2014-11-20*****************/
                       byte[] bf = new byte[packesize];
                        Array.Copy(bfCRC, it * packesize, bf, 0, packesize);
                        data = packetData(0xfd,bf, packesize);
                        try
                        {
                            if (!isUsedTcp)
                            {
                                udpclient1.Send(data, data.Length, endpoint);
                            }
                            else {
                                msocket.Send(data, data.Length, SocketFlags.None);
                            }
                            this.Invoke(new Func<string>(delegate() { lb_index.Text =(it+1).ToString(); return it.ToString(); }));
                        }
                        catch (ObjectDisposedException) {
                            break;
                        }
                    //    sendkey = true;    //open the send data thread key
                        //part = 10;         //enabled resend machine
                        _waitHandle.WaitOne(50000);
                    }
                    if (fislength % packesize > 0)
                    {
                        byte[] bf1 = new byte[fislength % packesize];
                        Array.Copy(bfCRC, it * packesize, bf1, 0, bf1.Length); // read the last data block from buffer and send it.
                        data = packetData(0xfd,bf1, bf1.Length); //最后一包数据没有重发机制                       
                        if (!isUsedTcp)
                        {
                            udpclient1.Send(data, data.Length, endpoint);
                        }
                        else {
                            msocket.Send(data, data.Length, SocketFlags.None);
                        }
                        this.Invoke(new Func<string>(delegate() { lb_index.Text =(it + 1).ToString(); return it.ToString(); }));
                    //    fsp.Close();
                    }
                    _waitHandle.WaitOne(50000);
                  //  part = 0;
                    data = packetData(0xfb, new byte[]{0x00}, 1); //最后一包数据没有重发机制 
                    if (!isUsedTcp)
                    {
                        udpclient1.Send(data, data.Length, endpoint);
                    }
                    else {
                        msocket.Send(data, data.Length, SocketFlags.None);
                    }

                }
                catch (FileNotFoundException)
                {
                }
                catch (IOException)
                {
                }
                Thread.Sleep(800);
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        private delegate void Setbp1_Text(string str, int value, bool isset);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="str">file name</param>
        /// <param name="value">value</param>
        /// <param name="isset">true maxnumb</param>
        private void Setbp_Box(string str, int value, bool isset)
        {
            if (this.InvokeRequired)
            {
                Setbp1_Text d = new Setbp1_Text(Setbp_Box);
                this.Invoke(d, new object[] { str, value, isset });
            }
            else
            {
                if (isset)
                {
                    this.pb_updateStep.Maximum = value;
                    lb_file_info.Text = "Upload...";
                }
                else
                {
                    if (value >= 0)
                    {
                        this.pb_updateStep.Value = value;
                        if (value >= k)
                        {
                            lb_file_info.Text = "Upload successfully";
                        }
                    }
                    else if (isSave) {
                        lb_file_info.Text = "Save and Reboot";
                    }
                    else
                    {
                        lb_file_info.Text = "Upload Error";
                    }
                }
            }
        }
        Boolean isSave = false;
        private void button19_Click(object sender, EventArgs e)
        {
            byte[] data = packetData(0xfa, new byte[] { 0xce }, 1); //警告，最后一包数据没有重发机制                    
            if (!isUsedTcp)
            {
                endpoint = new IPEndPoint(IPAddress.Parse(tb_updateIP.Text.Trim()), 17789);
                receiveEndpoint = endpoint;
                udpclient1 = new UdpClient();
                udpclient1.Send(data, data.Length, new IPEndPoint(IPAddress.Parse(tb_updateIP.Text.Trim()), 17789));
                isSave = true;
            }
            else
            {
                isSave = true;
                msocket.Send(data, data.Length, SocketFlags.None);
            }
        }

        private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
        {
           // endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), 17789);//update 7789 szbh configPort
          ///  udpclient1.Send(new byte[]{0x00}, 1, endpoint);
        }
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (udpConfig != null)
            {
                udpConfig.Close();
            }
            isReceive = false;
            configReceiveData_switch = false;
            if (td != null) { td.Abort(); }
            if (udpclient1!=null)
            {
                udpclient1.Close();
            }
            try
            {
                walkTcpClient.Close();
                msocket.Close();
            }catch(NullReferenceException)
            {
                
            }
        }

        private void button8_Click(object sender, EventArgs e)
        {

        }

        private void button7_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(12, Encoding.Unicode.GetBytes(textBox1.Text).Length, Encoding.Unicode.GetBytes(textBox1.Text));
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }
        private void button2_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(9, 1, new byte[] { 0x02 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }

        private void button3_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(9, 1, new byte[] { 0x03 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }

        private void button4_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(9, 1, new byte[] { 0x04 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }

        private void button5_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(9, 1, new byte[] { 0x05 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(9, 1, new byte[] { 0x06 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
            receiveConfigEndpoint = endpoint;
        }

        private void button20_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(11, Encoding.Unicode.GetBytes(textBox2.Text).Length, Encoding.Unicode.GetBytes(textBox2.Text));
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if(udpConfig!=null){udpConfig.Send(m, m.Length, endpoint);}else{MessageBox.Show("client is none");}
        }

        private void btn_enR_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x10, 1, new byte[]{0x01});
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
        }

        private void btn_enG_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x10, 1, new byte[] { 0x02 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
        }

        private void btn_enB_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x10, 1, new byte[] { 0x03 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
        }

        private void btn_enY_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x10, 1, new byte[] { 0x04 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
        }
        private void btn_enW_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x10, 1, new byte[] { 0x05 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
        }

        private void button10_Click(object sender, EventArgs e)
        {
          
            byte[] m = pack_data(0x0d, 1, new byte[] { 0x01 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
            receiveConfigEndpoint = endpoint;
        }

        private void button11_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x0e, 1, new byte[] { 0x01 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
            receiveConfigEndpoint = endpoint;
        }

        private void button12_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x0e, 1, new byte[] { 0x00 });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
            receiveConfigEndpoint = endpoint;
        }
     //   int enR = 0, enG = 0, enB = 0;
        private void button13_Click(object sender, EventArgs e)
        {
            byte[] m = pack_data(0x0f, 3, new byte[] { (byte)trackBar2.Value, (byte)trackBar3.Value, (byte)trackBar4.Value });
            endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
            if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
            receiveConfigEndpoint = endpoint;
        }
        private Boolean ischanged = false;
        private void trackBar1_MouseUp(object sender, MouseEventArgs e)
        {
            if (ischanged)
            {
                ischanged = false;
                 byte[] m = pack_data(0x0a, 1, new byte[] { (byte)trackBar1.Value });
                  endpoint = new IPEndPoint(IPAddress.Parse(tb_remoteip.Text), configPort);
                  if (udpConfig != null) { udpConfig.Send(m, m.Length, endpoint); } else { MessageBox.Show("client is none"); }
                  receiveConfigEndpoint = endpoint;
            }
        }
        /// <summary>
        /// 默认为false，使用UDP通信
        /// </summary>
        private Boolean isUsedTcp = false;
        private void rb_isTcp_CheckedChanged(object sender, EventArgs e)
        {
            isUsedTcp = rb_isTcp.Checked;
        }
        private Socket msocket;// socketNow;
        private TcpClient walkTcpClient = null;
        private void button14_Click(object sender, EventArgs e)
        {
            int remotePort = 17787;
            walkTcpClient = new TcpClient();
            msocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint remoteIP = new IPEndPoint(IPAddress.Parse(tb_updateIP.Text), remotePort);
            try
            {

                msocket.Connect(remoteIP);
                Thread.Sleep(1000);
                if (msocket.Available > 10)
                {
                    byte[] buf=new byte[128];
                    int len=msocket.Receive(buf);
                    label24.Text="Firmware Version: "+ Encoding.ASCII.GetString(buf, 0, len);
                    Thread rd = new Thread(new ThreadStart(data_Receive));
                    isReceive = true;
                    rd.Start();
                }
                //msocket.Send();
               // mthread1 = new Thread(new ThreadStart(netsenddata));
               // mthread1.Start();
               // mthread = new Thread(new ThreadStart(netreaddata));
              //  mthread.Start();
            }
            catch (SocketException e1)
            {
                MessageBox.Show(e1.Message + "\n Port has been openned");
              //  this.Invoke(new Func<string>(delegate() { tslb_info.Text = "Port has been openned"; return "Port has been openned"; }));
            }
        }
        private int mlock = 0;
        private void label36_Click(object sender, EventArgs e)
        {
            mlock++;
            if (mlock > 5)
            {
                mlock = -5;
                lb_remoteFile.Visible = true;
            }
            else if (mlock < 0)
            {
                lb_remoteFile.Visible = false;
            }
        }
    }
}
